home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / programm / MM2_DEV / S / MOS / STRINGS.D < prev    next >
Encoding:
Modula Definition  |  1990-05-06  |  8.0 KB  |  218 lines
  1. DEFINITION MODULE Strings;
  2.  
  3.  
  4. CONST StringSize = 80;  (* Max. Länge einer Var. vom Typ 'String' *)
  5.       MaxChars   = StringSize-1;
  6.  
  7.       End = 0C;         (* String-Terminator bei nicht-vollen Strings *)
  8.  
  9.  
  10. TYPE  String = ARRAY [0..MaxChars] OF CHAR;
  11.  
  12.       Relation = (less, equal, greater);
  13.  
  14. (*
  15.  * Der Paramter 'success', der bei vielen Funktionen auftritt, liefert
  16.  * immer nach einem Funktionsaufruf, ob ein Überlauf eines Strings bei
  17.  * der Operation aufgetreten ist oder ob ein Parameter ungültig war.
  18.  * Nur wenn dies nicht eintritt, ist 'success' nach dem Aufruf TRUE.
  19.  * Es bietet sich an, in jedem Modul eine globale Variable (z.B 'ok')
  20.  * als BOOLEAN zu deklarieren, die dann überall dort als 'success'-
  21.  * Parameter übergeben wird, wo diese Information nicht benötigt wird.
  22.  *
  23.  * Die Beispiele zeigen, was passiert, wenn Überläufe auftreten oder
  24.  * Argumente außerhalb des gültigen Bereichs liegen.
  25.  *
  26.  * Es werden also keine Laufzeitfehler ausgelöst.
  27.  *
  28.  *
  29.  * Für die ganz aufmerksamen Mitdenker:
  30.  *
  31.  *   Die Funktionen kommen trotz der REF-Parameter damit klar, wenn
  32.  * einer der 'source'-Argumente bei Aufruf identisch mit der Ziel-
  33.  * Variable ist.
  34.  *   Beispiel:
  35.  *     Concat (a, a, a, success)
  36.  *   macht keine Fehler, weil trotz der REF-Übergabe, bei der 'a' nicht
  37.  *   kopiert wird, sondern nur seine Adr. übergeben wird, die Funktion
  38.  *   dafür sorgt, daß beim Zusammensetzen von 'a' keine Überschneidungen
  39.  *   intern auftreten.
  40.  *)
  41.  
  42. PROCEDURE Pos ( REF pattern, source: ARRAY OF CHAR; start: INTEGER ): INTEGER;
  43.   (* Sucht ab der Position 'start' den String 'pattern' in 'source'.
  44.    * Liefert -1, wenn nicht gefunden, sonst die Position. *)
  45.  
  46. PROCEDURE PosLen ( REF pattern, source: ARRAY OF CHAR; start: INTEGER ): CARDINAL;
  47.   (* Wie 'Pos', liefert aber 'Length (source)', wenn nicht gefunden. *)
  48.  
  49. PROCEDURE StrEqual ( REF left, right: ARRAY OF CHAR ): BOOLEAN;
  50.   (* Liefert TRUE, wenn die beiden Strings gleich sind. *)
  51.  
  52. PROCEDURE Compare ( REF left, right: ARRAY OF CHAR ): Relation;
  53.   (* Vergleicht zwei Strings. Liefert je nach Ergebnis 'equal' (gleich),
  54.    * 'less' (left<right) oder 'greater' (left>right). Der Vergleich wird
  55.    * auf der Basis der Ordnungswerte der einzelnen Zeichen durchgeführt,
  56.    * jedoch werden alle Umlaute direkt hinter den zugehörigen Vokalen
  57.    * eingeordnet. Beispiele:
  58.    *  Compare ( 'a', 'b' )     = less
  59.    *  Compare ( 'b', 'bb' )    = less
  60.    *  Compare ( ' 1', '00' )   = less
  61.    *  Compare ( 'o', 'ö' )     = less
  62.    *  Compare ( 'p', 'ö' )     = greater
  63.    *  Compare ( 'ö', 'oa' )    = less
  64.    *  Compare ( 'ö', 'oe' )    = less
  65.    *)
  66.  
  67. (*
  68.  * Die Parameter der folgenden Funktionen sind nach folgender Regel angeordnet:
  69.  *  Zuerst Source-String(s), dann evtl. Positions-/Längenangaben, dann evtl.
  70.  *  Destination-String(s), zuletzt ein 'success'-Parameter, sofern nötig.
  71.  *)
  72.  
  73. PROCEDURE Assign ( REF source : ARRAY OF CHAR;
  74.                    VAR dest   : ARRAY OF CHAR;
  75.                    VAR success: BOOLEAN        );
  76.   (*
  77.    * Weist 'source' auf 'dest' zu.
  78.    * Beispiel:
  79.    *   VAR dest: ARRAY [0..2] OF CHAR;
  80.    *   Assign ( 'abcd', dest, success ) -> dest = 'abc', success = FALSE
  81.    *)
  82.  
  83. PROCEDURE Delete ( VAR str    : ARRAY OF CHAR;
  84.                        pos    : INTEGER;
  85.                        len    : INTEGER;
  86.                    VAR success: BOOLEAN        );
  87.   (*
  88.    * Löscht in 'str' ab Position 'pos' 'len' Zeichen.
  89.    * Beispiel:
  90.    *   str:= '123456';
  91.    *   Delete ( str, 2, 1, success ) -> str = '12456', success = TRUE
  92.    *   Delete ( str, 2, 6, success ) -> str = '12',    success = FALSE
  93.    *   Delete ( str,-1, 2, success ) -> str = '23456', success = FALSE
  94.    *   Delete ( str, 5, 0, success ) -> str = '123456',success = TRUE
  95.    *   Delete ( str, 8, 0, success ) -> str = '123456',success = FALSE
  96.    *)
  97.  
  98.  
  99. PROCEDURE Append ( REF source : ARRAY OF CHAR;
  100.                    VAR dest   : ARRAY OF CHAR;
  101.                    VAR success: BOOLEAN        );
  102.  
  103.   (*
  104.    * Fügt 'source' an 'dest' an.
  105.    * Beispiel:
  106.    *   VAR dest: ARRAY [0..4] OF CHAR;
  107.    *   dest:= 'abc';
  108.    *   Append ( 'def', dest, success ) -> dest = 'abcde', success = FALSE
  109.    *)
  110.  
  111. PROCEDURE Insert ( REF source : ARRAY OF CHAR;
  112.                        pos    : INTEGER;
  113.                    VAR dest   : ARRAY OF CHAR;
  114.                    VAR success: BOOLEAN        );
  115.   (*
  116.    * Fügt 'source' an Position 'pos' in 'dest' ein.
  117.    * Ist 'pos' < 0, wird nur hinterer Teil v. 'source' eingefügt, 'success'
  118.    * ist dann immer FALSE.
  119.    * Von 'source' wird nur soviel eingefügt, daß nichts von 'dest' verloren
  120.    * geht.
  121.    * 'success':= ( Length(source)=0 ) OR ( 'source' wurde ohne Verlust eingefügt )
  122.    * Beispiel:
  123.    *   VAR dest: ARRAY [0..9] OF CHAR;
  124.    *   dest:= '123';
  125.    *   Insert ( 'abcde', -2, dest, success ) -> dest = 'cde123', success=FALSE
  126.    *)
  127.  
  128. PROCEDURE Copy ( REF source : ARRAY OF CHAR;
  129.                      pos    : INTEGER;
  130.                      len    : INTEGER;
  131.                  VAR dest   : ARRAY OF CHAR;
  132.                  VAR success: BOOLEAN        );
  133.   (*
  134.    * Kopiert ab Position 'pos' 'len' Zeichen aus 'source' nach 'dest'.
  135.    * Beispiel:
  136.    *   VAR dest: ARRAY [0..3] OF CHAR;
  137.    *   source:= '123';
  138.    *   Copy ( source, -2, 2, dest, success ) -> dest = '',  success=FALSE
  139.    *   Copy ( source,  2, 0, dest, success ) -> dest = '',  success=TRUE
  140.    *   Copy ( source,  2, 2, dest, success ) -> dest = '3', success=FALSE
  141.    *)
  142.  
  143.  
  144. PROCEDURE Concat ( REF source1: ARRAY OF CHAR;
  145.                    REF source2: ARRAY OF CHAR;
  146.                    VAR dest   : ARRAY OF CHAR;
  147.                    VAR success: BOOLEAN        );
  148.   (*
  149.    * Fügt die Strings 'source1' und 'source2' in 'dest' zusammen.
  150.    * Beispiel:
  151.    *   VAR dest: ARRAY [0..2] OF CHAR;
  152.    *   Concat ( '1234', '56', dest, success ) -> dest = '123', success=FALSE
  153.    *   Concat ( '12', '34, dest, success )    -> dest = '123', success=FALSE
  154.    *)
  155.  
  156. PROCEDURE Split ( REF source : ARRAY OF CHAR;
  157.                       pos    : INTEGER;
  158.                   VAR dest1  : ARRAY OF CHAR;
  159.                   VAR dest2  : ARRAY OF CHAR;
  160.                   VAR success: BOOLEAN );
  161.   (* Kopiert source[0]..source[pos-1] nach dest1, Rest nach dest2.
  162.    * 'success' liefert FALSE, wenn 'pos'>Length(source) oder wenn die 'dest'-
  163.    * Strings zu klein sind. *)
  164.  
  165. PROCEDURE Chr ( REF s: ARRAY OF CHAR; n: CARDINAL ): CHAR;
  166.   (*
  167.    * Liefert das Zeichen an der Position 'n' aus dem String 's'.
  168.    * Ist der String kürzer als 'n', wird der Wert 0C geliefert.
  169.    *)
  170.  
  171. PROCEDURE Upper ( VAR dest: ARRAY OF CHAR );
  172.   (* Konvertiert alle Buchstaben in Großbuchstaben.             *)
  173.   (* Es werden auch die internationalen Umlaute berücksichtigt! *)
  174.  
  175. PROCEDURE Lower ( VAR dest: ARRAY OF CHAR );
  176.   (* Konvertiert alle Buchstaben in Kleinbuchstaben.            *)
  177.   (* Es werden auch die internationalen Umlaute berücksichtigt! *)
  178.  
  179. PROCEDURE DelBlanks ( VAR dest: ARRAY OF CHAR );
  180.   (* Löscht alle Leerzeichen und TAB-Zeichen. *)
  181.  
  182. PROCEDURE DelLeadingBlanks ( VAR s: ARRAY OF CHAR );
  183.   (* Löscht führende Leerzeichen und TABs *)
  184.  
  185. PROCEDURE DelTrailingBlanks ( VAR s: ARRAY OF CHAR );
  186.   (* Löscht anhängende Leerzeichen und TABs *)
  187.  
  188. PROCEDURE EatSpaces ( VAR dest: ARRAY OF CHAR );
  189.   (* Löscht alle Leerzeichen. *)
  190.  
  191. PROCEDURE Space ( n: INTEGER ): String;
  192.   (*
  193.    * Liefert einen String mit 'n' Leerzeichen.
  194.    * 'n' darf nicht größer als 80 sein.
  195.    *)
  196.  
  197. PROCEDURE Length ( REF str: ARRAY OF CHAR ): CARDINAL;
  198.   (*
  199.    * Relikt aus alten Tagen.
  200.    *
  201.    * Kann zwar verwendet werden, aber optimaler, weil schneller, ist
  202.    * die neue Standard-Funktion LENGTH.
  203.    *)
  204.  
  205. PROCEDURE Empty ( REF str: ARRAY OF CHAR ): BOOLEAN;
  206.   (*
  207.    * Relikt aus alten Tagen.
  208.    *
  209.    * Kann zwar verwendet werden, aber optimaler, weil schneller, ist
  210.    * der Vergleich der ersten Feldelements mit dem Terminierungs-Zeichen:
  211.    *   Statt
  212.    *     IF Empty (stringVar) THEN ...
  213.    *   schreiben Sie nun
  214.    *     IF stringVar[0] = '' THEN ...
  215.    *)
  216.  
  217. END Strings.
  218.